Method and relative quantum gate for running a grover&#39;s or a Deutsch-Jozsa&#39;s quantum algorithm

ABSTRACT

A method of performing a Grover&#39;s or a Deutsch-Jozsa&#39;s quantum algorithm being input with a binary function defined on a space having a basis of vectors of n of qubits includes carrying out a superposition operation over input vectors for generating components of linear superposition vectors referred to a second basis of vectors of n+1 qubits. An entanglement operation is performed over components of the linear superposition vectors for generating components of numeric entanglement vectors. The method allows a non-negligible time savings because the entanglement operation does not multiply a superposition vector for an entanglement matrix, but generates components of an entanglement vector simply by copying or inverting respective components of the superposition vector depending on values of the binary function. An interference operation is performed over components of the numeric entanglement vectors for generating components of output vectors.

FIELD OF THE INVENTION

[0001] The present invention relates to quantum algorithms, and more precisely, to a method for performing a Grover's or a Deutsch-Jozsa's quantum algorithm and a corresponding quantum gate.

BACKGROUND OF THE INVENTION

[0002] Quantum search algorithms are global random searching algorithms based on the principles, laws and effects of quantum mechanics. They are used for controlling a process or for processing data in a database, and more specifically, for controlling a process that may include search-of-minima intelligent operations.

[0003] In a quantum search, each design variable is represented by a finite linear superposition of initial states, with a sequence of elementary unitary steps manipulating the initial quantum state (for the input) such that a measurement of the final state of the system yields the correct output. Usually, three principle operators, i.e., linear superposition (coherent states), entanglement and interference are used in the quantum search algorithm.

[0004] For a better understanding, a brief description of quantum search algorithms is provided. The problems solved by quantum algorithms may be stated as follows: Input A function f: {0, 1}^(n) → {0, 1}^(m) Problem Find a certain property of f

[0005] The structure of a quantum algorithm is outlined by a high level representation in the schematic diagram of FIG. 1.

[0006] The input of a quantum algorithm is a function f from binary strings into binary strings. This function is represented as a map table, which defines for every string its image. Function f is first encoded into a unitary matrix operator U_(F) depending on f properties. This operator calculates f when its input and output strings are encoded into canonical basis vectors of a Complex Hilbert Space: U_(F) maps the vector code of every string into the vector code of its image by f. $\begin{matrix} {\quad {{BOX}\quad 1\text{:}\quad {UNITARY}\quad {MATRIX}\quad U_{F}}} \\ {A\quad {squared}\quad {matrix}\quad U_{F}\quad {on}\quad {the}\quad {complex}\quad {field}\quad {is}\quad {unitary}} \\ {{if}\quad {its}\quad {inverse}\quad {matrix}\quad {coincides}\quad {with}\quad {its}\quad {conjugate}} \\ {{transposition}\text{:}} \\ {\quad {U_{F}^{- 1} = U_{F}}} \\ {A\quad {unitary}\quad {matrix}\quad {is}\quad {always}\quad {reversible}\quad {and}\quad {preserves}} \\ {{the}\quad {norm}\quad {of}\quad {{vectors}.}} \end{matrix}\quad$

[0007] When the matrix operator U_(F) has been generated, it is embedded into a quantum gate G, a unitary matrix whose structure depends on the form of matrix U_(F) and on the problem to be solved. The quantum gate is the core of a quantum algorithm. In every quantum algorithm, the quantum gate acts on an initial canonical basis vector (the same vector may always be chosen) to generate a complex linear combination (called a superposition) of basis vectors as the output. This superposition contains all the information to answer the initial problem.

[0008] After this superposition has been created, a measurement takes place to extract this information. In quantum mechanics, measurement is a non-deterministic operation that produces as output only one of the basis vectors. The probability of every basis vector being the output of a measurement depends on its complex coefficient (probability amplitude) in entering a complex linear combination.

[0009] The segmental action of the quantum gate and of the measurement forms the quantum block. The quantum block is repeated k times to produce a collection of k basis vectors. In measuring a non-deterministic operation, these basis vectors would not be necessarily identical and each one of them will encode a piece of the information needed to solve the problem.

[0010] The last part of the algorithm includes interpretation of the collected basis vectors to get the right answer for the initial problem with a certain probability.

[0011] The behavior of the encoder block is described in the detailed schematic diagram of FIG. 2. Function f is encoded into matrix U_(F) in three steps.

[0012] Step 1: The map table of function f: {0,1}^(n)→{0,1}^(m) is transformed into the map table of the infective function F: {0,1}^(n+m)→{0,1}^(n+m) such that:

F(x ₀ , . . . , x _(n−1) , y ₀ , . . . , y _(m−1))=(x ₀ , . . . , x _(n−1) , f(x ₀ , . . . , x _(n−1))⊕(y ₀ , . . . , y _(m−1)))  (1)

[0013] $\begin{matrix} {{{BOX}\quad 2\text{:}\quad {XOR}\quad {OPERATOR}}\quad \oplus} \\ {{The}\quad {XOR}\quad {operator}\quad {between}\quad {two}\quad {binary}\quad {strings}\quad p\quad {and}\quad q} \\ {{{of}\quad {length}\quad m\quad {is}\quad a\quad {string}\quad s\quad {of}\quad {length}\quad m\quad {such}\quad {that}\quad {the}}\quad} \\ {{i\text{-}{th}\quad {digit}\quad {of}\quad s\quad {is}\quad {calculated}\quad {as}\quad {the}\quad {exclusive}\quad {OR}}\quad} \\ {{{between}\quad {the}\quad i\text{-}{th}\quad {digits}\quad {of}\quad p\quad {and}\quad q\text{:}}\quad} \\ {\quad {p = \left( {p_{0},\ldots \quad,p_{n - 1}} \right)}} \\ {\quad {q = \left( {q_{0},\ldots \quad,q_{n - 1}} \right)}} \\ \left. {s = {{p \oplus q} = \left( {{\left( {p_{0} + q_{0}} \right)\quad {mod}\quad 2},\ldots \quad,{\left( {p_{n - 1} + q_{n - 1}} \right)\quad {mod}\quad 2}} \right)}} \right) \end{matrix}$

[0014] The need to deal with an injective function comes from the requirement that U_(F) is unitary. A unitary operator is reversible, so it cannot map two different inputs in the same output. Given that U_(F) is the matrix representation of F, F is supposed to be infective. If the matrix representation of function f is directly used, a non-unitary matrix could be obtained since f could be non-injective. So, injectivity is fulfilled by increasing the number of bits and considering function F instead of function f. Function f can always be calculated from F by putting (y₀, . . . , y_(m−1))=(0, . . . , 0) in the input string and reading the last m values of the output string.

[0015] Step 2: Function F map table is transformed into a U_(F) map table, based upon the following constraint:

∀sε{0,1}^(n+m) : U _(F)[τ(s)]=τ[F(s)]  (2)

[0016] The code map τ:{0,1}^(n+m) 43 C² ^(n+m) (C² ^(n+m) is the target Complex Hilbert Space) is such that: $\begin{matrix} {{\tau (0)} = {\begin{pmatrix} 1 \\ 0 \end{pmatrix} = {{{0\rangle}\quad {\tau (1)}} = {\begin{pmatrix} 0 \\ 1 \end{pmatrix} = {1\rangle}}}}} \\ {{\tau \left( {x_{0},\ldots \quad,x_{n + m - 1}} \right)} = {{{\tau \left( x_{0} \right)} \otimes \quad \ldots \quad \otimes {\tau \left( x_{n + m - 1} \right)}} = {{x_{0}\ldots \quad x_{n + m - 1}}}}} \end{matrix}\quad$

(3) $\begin{matrix} {\quad {{BOX}\quad 3\text{:}\quad {VECTOR}\quad {TENSOR}\quad {{PRODUCT}\quad \otimes}}} \\ {{The}\quad {tensor}\quad {product}\quad {between}\quad {two}\quad {vectors}\quad {of}\quad {dimensions}} \\ {{h\quad {and}\quad k\quad {is}\quad a\quad {tensor}\quad {product}\quad {of}\quad {dimension}\quad {h \cdot k}},{such}} \\ {{that}\text{:}} \\ {{{{{{x\rangle} \otimes}}y}\rangle} = {{\begin{pmatrix} x_{1} \\ \ldots \\ x_{h} \end{pmatrix} \otimes \begin{pmatrix} y_{1} \\ \ldots \\ y_{k} \end{pmatrix}} = \left. \begin{pmatrix} {x_{1}y_{1}} \\ \ldots \\ {x_{1}y_{k}} \\ \ldots \\ {x_{h}y_{1}} \\ \ldots \\ {x_{h}y_{k}} \end{pmatrix}\Rightarrow\begin{matrix} \underset{\_}{{Physical}\quad {interpretation}\text{:}} \\ \text{If a~~component of a complex vector is interpreted as the proabability amplitude of a  system in a given state (indexed by the component number), the tensor products between two vectors describes the joint probability amplitude of two systems in a joint state.} \end{matrix} \right.}} \end{matrix}$

[0017] Examples: Vector Tensor Products ${{{{{{{{{{{{\left( {0,0} \right)\overset{\tau}{}\begin{pmatrix} 1 \\ 0 \end{pmatrix}} \otimes \begin{pmatrix} 1 \\ 0 \end{pmatrix}} = {\begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \end{pmatrix} = {00}}}\rangle}\quad {{\left( {0,1} \right)\overset{\tau}{}\begin{pmatrix} 1 \\ 0 \end{pmatrix}} \otimes \begin{pmatrix} 0 \\ 1 \end{pmatrix}}} = {\begin{pmatrix} 0 \\ 1 \\ 0 \\ 0 \end{pmatrix} = {01}}}\rangle}\quad {{{\left( {1,0} \right)\overset{\tau}{}\begin{pmatrix} 0 \\ 1 \end{pmatrix}} \otimes \begin{pmatrix} 1 \\ 0 \end{pmatrix}} = {\begin{pmatrix} 0 \\ 0 \\ 1 \\ 0 \end{pmatrix} = {10}}}}\rangle}\quad {{\left( {1,1} \right)\overset{\tau}{}\begin{pmatrix} 0 \\ 1 \end{pmatrix}} \otimes \begin{pmatrix} 0 \\ 1 \end{pmatrix}}} = {\begin{pmatrix} 0 \\ 0 \\ 0 \\ 1 \end{pmatrix} = {11}}}\rangle}\quad$

[0018] Code τ maps bit values into complex vectors of dimension 2 belonging to the canonical basis of C². Besides using the tensor product, τ maps the general state of a binary string of dimension n into a vector of dimension 2 ^(n), for reducing this state to the joint state of the n bits composing the register. Every bit state is transformed into the corresponding 2-dimensional basis vector, and then the string state is mapped into the corresponding 2^(n)-dimensional basis vector by composing all bit-vectors through tensor product. In this sense, the tensor product is the vector counterpart of a state conjunction.

[0019] Basis vectors are denoted using the ket notation |i>. This notation is taken from the Dirac description of quantum mechanics.

[0020] Step 3: U_(F) map table is transformed into U_(F) using the following transformation rule:

[U _(F)]_(ij)=1

U _(F) |j>=|i>  (4)

[0021] which can be easily understood considering vectors |i> and |j> as column vectors. Associating these vectors to the canonical basis, U_(F) defines a permutation map of the identity matrix rows. In general, row |j> is mapped into row |i>. This rule will be illustrated in detail in an example quantum algorithm: Grover's algorithm.

[0022] The core of the quantum block is the quantum gate, which depends on the properties of matrix U_(F). The scheme in FIG. 3 gives a more detailed description of the quantum block. The matrix operator U_(F) in FIG. 3 is the output of the encoder block represented in FIG. 2. Here, it becomes the input for the quantum block.

[0023] This matrix operator is first embedded into a more complex gate: the quantum gate G. Unitary matrix G is applied k times to an initial canonical basis vector |i> of dimension 2 ^(n+m). Every time, the resulting complex superposition G|0 . . . 01 . . . 1> of basis vectors is measured, and produces one basis vector |x_(i)> as a result. All the measured basis vectors {|x₁>, . . . , |x_(k)>} are collected together. This collection is the output of the quantum block.

[0024] The intelligence of such algorithms is in the ability to build a quantum gate that is able to extract the information necessary to find the required property of f and to store it into the output vector collection. The structure of the quantum gate for every quantum algorithm will be discussed in detail, observing that a general description is possible. To represent quantum gates some special diagrams called quantum circuits are going to be used.

[0025] An example of a quantum circuit, relative to the so called Deutsch-Jozsa's quantum algorithm, is illustrated in FIG. 4. Every rectangle is associated to a 2^(n)×2^(n) matrix, where n is the number of lines entering and leaving the rectangle. For example, the rectangle marked U_(F) is associated to matrix U_(F). Typically, matrix H represents a Hadamard rotation: $\begin{matrix} {H = {\frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & {- 1} \end{bmatrix}}} & (5) \end{matrix}$

[0026] Quantum circuits provide a high-level description of the gate, and using some of the transformation rules are listed in FIGS. 5A-5F it is possible to compile them into the corresponding gate-matrix. $\begin{matrix} \underset{\_}{{BOX}\quad 4\text{:}\quad {MATRIX}\quad {TENSOR}\quad {{PRODUCT}\quad \otimes}} \\ {{The}\quad {tensor}\quad {product}\quad {between}\quad {two}\quad {matrices}\quad X_{n \times m}\quad {and}\quad Y_{h \times k}} \\ {{{is}\quad a\quad ({block})\quad {matrix}\quad \left( {n \cdot h} \right) \times \left( {m \cdot k} \right)\quad {such}\quad {that}\text{:}}\quad} \\ {{X \otimes Y} = {{\begin{bmatrix} {x_{11}Y} & \ldots & {x_{1m}Y} \\ \ldots & \ldots & \ldots \\ {x_{n1}Y} & \ldots & {x_{nm}Y} \end{bmatrix}\quad {with}\quad X} = \begin{bmatrix} x_{11} & \ldots & x_{1m} \\ \ldots & \ldots & \ldots \\ x_{n1} & \ldots & x_{nm} \end{bmatrix}}} \end{matrix}$

[0027] Example—Matrix Tensor Product: $\begin{matrix} {{\begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \otimes \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}} = \left\lbrack {\begin{matrix} {1 \cdot \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}} \\ {3 \cdot \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}} \end{matrix}\quad \begin{matrix} {2 \cdot \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}} \\ {4 \cdot \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}} \end{matrix}} \right\rbrack} \\ {= \begin{bmatrix} 5 & 6 & 10 & 12 \\ 7 & 8 & 14 & 16 \\ 15 & 18 & 20 & 24 \\ 21 & 24 & 28 & 32 \end{bmatrix}} \end{matrix}$

[0028] It will be clearer how to use these rules when the first example of a quantum algorithm will be discussed in greater detail below.

[0029] The decoder block has the function to interpret the basis vectors collected after the iterated execution of the quantum block. Decoding these vectors means to retranslate them into binary strings and interpreting them directly if they already contain the answer to the starting problem or use them, for instance as coefficients vectors for an equation system, in order to get the searched solution. This part will not be investigated in detail because it is relatively straightforward to understand by those skilled in the art.

[0030] Because of the particular importance of the Grover's quantum algorithm in the realization of controllers and of data search algorithms in databases, a brief description of the Grover's algorithm is given. Grover's problem is stated as follows: Input A function f: {0, 1}^(n) → {0, 1} such that ∃x∈{0, 1}^(n): (f(x) = 1

∀y∈{0, 1}^(n): x ≠ y

f(y) = 0) Problem Find x

[0031] In Deutsch-Jozsa's algorithm there are two classes of input functions and it must be determined what class the input function belonged to. In this case the problem is almost identical in its form, even if it is more difficult because now we are dealing with 2^(n) classes of input functions (each function of the kind described forms a class).

[0032] The diagram of the Grover's algorithm is depicted in FIG. 6, and the gate equation is as follows:

φ=[(D _(n)

I)·U _(F)]^(h)·(^(n+1) H)  (6)

[0033] Operator D_(n) is called a diffusion matrix of order n and it is responsible for interference in this algorithm. This matrix is defined as follows: D_(n) |0 . . . 0> |0 . . . 1> . . . |i> . . . |1 . . . 0> |1 . . . 1> |0 . . . 0> −1 + 1/2^(n-1) 1/2^(n-1) . . . 1/2^(n-1) . . . 1/2^(n-1) 1/2^(n-1) |0 . . . 1> 1/2^(n-1) −1 + 1/2^(n-1) . . . 1/2^(n-1) . . . 1/2^(n-1) 1/2^(n-1) . . . . . . . . . . . . . . . . . . . . . . . . |i> 1/2^(n-1) 1/2^(n-1) . . . −1 + 1/2^(n-1) . . . 1/2^(n-1) 1/2^(n-1) . . . . . . . . . . . . . . . . . . . . . . . . |1 . . . 0> 1/2^(n-1) 1/2^(n-1) . . . 1/2^(n-1) . . . −1 + 1/2^(n-1) 1/2^(n-1) |1 . . . 1> 1/2^(n-1) 1/2^(n-1) . . . 1/2^(n-1) . . . 1/2^(n-1) −1 + 1/2^(n-1)

[0034] Grover's algorithm may be implemented in routines for searching a desired item in a set, by representing in vector form each item of the set forming an input set of vectors, and by applying a Grover's algorithm to this set of vectors. The output vector represents the desired item.

[0035] The implementation of a Grover's algorithm clearly implies the calculation of several vector products. In fact, all qubits must be multiplied by matrix H, then by the entanglement matrix U_(F) and all qubits but the latter must be multiplied by matrix D_(n).

[0036] These multiplications could be carried out via software, but it is quite-evident that the number of qubits of a quantum algorithm could be very critical in terms of computational speed. In fact, referring to the scheme in FIG. 6, the addition of only one qubit doubles the dimensions of the matrices. Thus, the number of elements (and of products) increases exponentially.

[0037] A method of performing the superposition operation of a Grover's or of a Deutsch-Jozsa's quantum algorithm over an input set of vectors is disclosed in European patent application EP01830383.4, which is assigned to the current assignee of the present invention. This method exploits the fact that any rotated vector obtained performing the Hadamard rotation (on an input vector) contemplated by the superposition operation of these quantum algorithms can be easily encoded in a binary vector. Therefore, the successive tensor product of the rotated vectors for generating linear superposition vectors can be carried out by logic gates. This fact allows a noticeable time saving because logic gates are very fast.

[0038] However, this is not sufficient to significantly speed up these quantum algorithms because the entanglement matrix U_(F) is a 2^(n+1)×2^(n+1) square matrix, which implies a considerable computational weight both in the Grover's algorithm as well as in the Deutsch-Jozsa's algorithm.

SUMMARY OF THE INVENTION

[0039] An object of the present invention is to provide a method and a corresponding quantum gate for increasing the speed of performing entanglement operations in a Deutsch-Jozsa's or a Grover's quantum algorithm.

[0040] A large number of multiplications required by the entanglement operation gives a null result because only one component per row of the entanglement matrix U_(F) is not a null. The entanglement operation generates an entanglement vector by permuting or not permuting a couple of opposite components of a linear superposition vector. This is dependent on the value assumed by the function f(.). More specifically, if function f(.) is null in correspondence to the vector identified by the first (leftmost) n qubits in common with the two n+1 qubit vectors to which a couple of opposite components of which the superposition vector is referred to, then the corresponding couple of components of the entanglement vector is equal to that of the superposition vector. Otherwise, it is the opposite.

[0041] Therefore, it is not necessary to calculate the entanglement matrix U_(F) to generate an entanglement vector from a superposition vector. It is sufficient to copy or invert components of a superposition vector to generate corresponding components of an entanglement vector depending on the values of the function f(.) processed by the quantum algorithm.

[0042] More precisely, the object of the present invention is to provide a method of performing a Grover's or a Deutsch-Jozsa's quantum algorithm using a certain binary function defined on a space having a basis of vectors of n of qubits. The method may comprise carrying out a superposition operation over input vectors for generating components of linear superposition vectors referred on a second basis of vectors of n+1 qubits, carrying out an entanglement operation over components of the linear superposition vectors for generating components of numeric entanglement vectors, and carrying out an interference operation over components of the numeric entanglement vectors for generating components of output vectors.

[0043] The method allows a non-negligible time saving because the entanglement operation is carried out by generating, for components of each superposition vector, corresponding components of a numeric entanglement vector. Each component referred to a respective vector of the second basis is equal to the corresponding component of the respective superposition vector if the binary function is null in correspondence to the vector of the first basis formed by the first n qubits of the respective vector of the second basis; or the opposite of the corresponding component of the respective superposition vector if the binary function is not a null in correspondence to the vector of the first basis formed by the first n qubits of the respective vector of the second basis.

[0044] This method can be implemented in a quantum gate for running a Grover's or a Deutsch-Jozsa's quantum algorithm using a certain binary function defined on a space having a basis of vectors of n of qubits. The quantum gate may comprise a superposition subsystem carrying out a superposition operation over components of input vectors for generating components of linear superposition vectors referred on a second basis of vectors of n+1 qubits. An entanglement subsystem carries out an entanglement operation over components of the linear superposition vectors for generating components of numeric entanglement vectors. An interference subsystem carries out an interference operation over components of the numeric entanglement vectors for generating components of output vectors.

[0045] The entanglement subsystem may comprise a command circuit generating a number (2^(n)) of logic command signals encoding the values of the binary function in correspondence to the vectors of the first basis. Circuit means may be input with the logic command signals that generate, for components of each superposition vector, corresponding signals representing components of a numeric entanglement vector.

[0046] Each component referred to a respective vector of the second basis may be equal to the corresponding component of the respective superposition vector if the binary function is null in correspondence to the vector of the first basis formed by the first n qubits of the respective vector of the second basis; or the opposite of the corresponding component of the respective superposition vector if the binary function is not a null in correspondence to the vector of the first basis formed by the first n qubits of the respective vector of the second basis.

BRIEF DESCRIPTION OF THE DRAWINGS

[0047] The particular aspects and advantages of the invention will become more evident through the following description of several important embodiments and by referring to the attached drawings, wherein:

[0048]FIG. 1 is a block diagram of a quantum algorithm in accordance with the prior art;

[0049]FIG. 2 is a block diagram of an encoder in accordance with the prior art;

[0050]FIG. 3 is a general structure of the block diagram illustrated in FIG. 1;

[0051]FIG. 4 is a circuit for a Deutsch-Jozsa's quantum gate in accordance with the prior art;

[0052]FIG. 5a shows an example of a tensor product transformation in accordance with the prior art;

[0053]FIG. 5b shows an example of a dot product transformation in accordance with the prior art;

[0054]FIG. 5c shows the identity transformation in accordance with the prior art;

[0055]FIG. 5d shows an example of the propagation rule in accordance with the prior art;

[0056]FIG. 5e shows an example of the iteration rule in accordance with the prior art;

[0057]FIG. 5f explains the input/output tensor rule in accordance with the prior art;

[0058]FIG. 6 is an example of a circuit forming a Grover's quantum gate in accordance with the prior art;

[0059]FIG. 7 is a graph of a function to be processed by a Grover's quantum algorithm in accordance with the present invention;

[0060]FIG. 8 is a detailed view of a superposition subsystem of the quantum gate in accordance with the present invention for a Grover's algorithm with one iteration;

[0061]FIG. 9 depicts the logic part of the entanglement subsystem of a quantum gate in accordance with the present invention for the function illustrated in FIG. 7;

[0062]FIG. 10 is a detailed view of the entanglement subsystem of the quantum gate in accordance with the present invention for a Grover's algorithm with one iteration;

[0063]FIG. 11 is a detailed view of the interference subsystem of the quantum gate in accordance with the present invention for a Grover's algorithm with one iteration.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0064] The quantum gate of the invention is suitable for fast running decision making or data search routines based on a Deutsch-Jozsa's or a Grover's quantum algorithm applied over a set of input vectors. The quantum gate of a superposition subsystem carrying out a linear superposition, an entanglement subsystem carrying out an entanglement operation and an interference subsystem carrying out an interference operation according to a Grover's or a Deutsch-Jozsa's quantum algorithm.

[0065] An essential characteristic of the quantum gate of the invention includes the fact that the entanglement subsystem does not multiply a superposition vector for the entanglement matrix U_(F), but generates components of an entanglement vector simply by copying or inverting respective components of the superposition vector depending on values of the function f(.).

[0066] This allows a relevant reduction of the number of multiplications with respect to known methods, and can be carried out with logic gates or multiplexers. For this reason, the quantum gate of the invention may be conveniently used for running decision making algorithms or data search routines in large databases in a very fast manner.

[0067] To show how the calculation of an entanglement vector can be speeded up by the method of the invention, an example of quantum search algorithm in which each vector is composed of two qubits is given. The present invention supports the extension to vectors of more than two qubits, as readily appreciated by those skilled in the art.

[0068] Let us consider a function f: {0,1}²→{0,1} having the following definition law: $\begin{matrix} \left\{ \begin{matrix} {{f(01)} = 1} \\ {{f\left( . \right)} = {0\quad {elsewhere}}} \end{matrix} \right. & (7) \end{matrix}$

[0069] whose diagram is depicted in FIG. 7. According to known methods, this function should be translated into a function F: {0,1}³→{0,1}³ and, therefore into the matrix U_(F): $\begin{matrix} {U_{F} = \begin{bmatrix} I & 0 & 0 & 0 \\ 0 & C & 0 & 0 \\ 0 & 0 & I & 0 \\ 0 & 0 & 0 & I \end{bmatrix}} & (8) \end{matrix}$

[0070] where $\begin{matrix} {I = {{\begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}\quad C} = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix}}} & (9) \end{matrix}$

[0071] The following linear superposition will now be considered: $\begin{matrix} {Y^{*} = {\quad{\quad\left\lbrack \begin{matrix} \frac{1}{2\sqrt{2}} & {- \frac{1}{2\sqrt{2}}} & \frac{1}{2\sqrt{2}} & {- \frac{1}{2\sqrt{2}}} & \frac{1}{2\sqrt{2}} & {- \frac{1}{2\sqrt{2}}} & \frac{1}{2\sqrt{2}} & \left. {- \frac{1}{2\sqrt{2}}} \right\rbrack^{T} \end{matrix} \right.}}} & (10) \end{matrix}$

[0072] Known methods contemplate generating components of the corresponding entanglement vector G*: $\begin{matrix} {G^{*} = {\quad\left\lbrack \begin{matrix} \frac{1}{2\sqrt{2}} & {- \frac{1}{2\sqrt{2}}} & {- \frac{1}{2\sqrt{2}}} & \frac{1}{2\sqrt{2}} & \frac{1}{2\sqrt{2}} & {- \frac{1}{2\sqrt{2}}} & \frac{1}{2\sqrt{2}} & \left. {- \frac{1}{2\sqrt{2}}} \right\rbrack^{T} \end{matrix} \right.}} & (11) \end{matrix}$

[0073] by calculating the product G*=U_(F)·Y*, which implies many (64) multiplications.

[0074] According to the method of the invention, the components of the vector G* are more easily obtained by copying or inverting the corresponding components of Y*, depending on the values assumed by the function f(.). More precisely, all components of vector G* but the third and the fourth are equal to the corresponding components of Y* because the function f(.) is 0 for vectors |00, |10> and |11>, while the third and the fourth components of G* are obtained by inverting the corresponding components of Y* because f(.) is 1 for vector |01>. As a consequence, the entanglement operation of Deutsch-Jozsa's or Grover's quantum algorithms can be implemented in straightforward and fast quantum gates.

[0075] A particular quantum gate of the invention, especially designed for carrying out the Deutsch-Jozsa's quantum algorithm or the Grover's algorithm with only one iteration (h=1), is depicted in FIGS. 8, 10 and 11. This quantum gate has a superposition subsystem, which can be as depicted in FIG. 8 and as disclosed in the above referenced European patent application EP01830383.4. The quantum gate further includes an entanglement subsystem made of logic gates and operational amplifiers, and an interference subsystem.

[0076] This particular embodiment of a quantum gate exploits the fact that the vector Y* can be encoded by using the transformation: $\begin{matrix} {Y = {\frac{1}{2y} \cdot \left( {Y^{*} + \left\lbrack {y\quad \ldots \quad y} \right\rbrack^{T}} \right)}} & (12) \end{matrix}$

[0077] where $y = \frac{1}{2\sqrt{2}}$

[0078] in the following encoded superposition vector:

Y=[10101010]^(T)  (13)

[0079] It is easy to demonstrate that the vector G that encodes the entanglement vector G*=U_(F)·Y* according to the cited transformation (equation 12) $\begin{matrix} {G = {\frac{1}{2y} \cdot \left( {G^{*} + \left\lbrack {y\quad \ldots \quad y} \right\rbrack^{T}} \right)}} & (14) \end{matrix}$

[0080] is G=U_(F)·Y. Therefore, components g_(i) of the encoded entanglement vector G can be obtained, according to the method of the invention, by copying or inverting the corresponding components y_(i) of the encoded superposition vector Y, depending on the values of function f(.). For the considered example, the encoded entanglement vector G is

G=[10011010]^(T)  (15)

[0081] which corresponds to the numeric entanglement vector given by equation 11.

[0082] An example of a logic circuit for carrying out the entanglement operation of a Grover's or Deutsch-Jozsa's algorithm is depicted in FIG. 9. Each logic gate XORs a component of the encoded superposition vector y_(i) with a corresponding value of the function f(.) for generating a corresponding component g_(i) of encoded entanglement vector. Each component y_(i) that is not a null is represented by a voltage of 3.5V, while each null component is represented by a null voltage.

[0083] The components of the encoded entanglement vector are then converted in corresponding components d1, . . . , d8 of a numeric entanglement vector by an array of digital/analog converters, depicted in FIG. 10. Each converter includes an adder that inverts the transformation given by equation 14. The output voltages d1, . . . d8 of the operational amplifiers are about ±0.3535 Volts, which corresponds to a numeric value of $\pm {\frac{1}{2\sqrt{2}}.}$

[0084] A more difficult task is to deal with the interference operation of a Grover's algorithm. In fact, differently from the entanglement operation, vectors generated by the interference operation are not composed by elements having only two possible values. Moreover, the presence of tensor products, whose number increases dramatically with the dimensions, forms a critical point at this step.

[0085] It is possible to quickly carry out the interference operation of a Grover's quantum algorithm. The matrix D_(n)

I has the following properties:

[0086] odd columns (or rows, because D_(n)

I is symmetric) have non-zero odd components and even columns have non-zero even components;

[0087] the value of all non-zero components, but the i^(th) component of i^(th) column (diagonal elements) is ½^(n−1). The components on the up-left down-right diagonal of the matrix differ from the other non-zero components because they are decreased by 1; and

[0088] since G* is the numeric entanglement vector, the output vector of the quantum algorithm V=(D_(n)

I) G* involves only a suitable weighted sum of components of G*, with the value ½^(n−1) depending only from the number n of qubits.

[0089] From the above analysis, the generic element v_(i) of V can be written as follows as a function of g_(i)*: $\begin{matrix} {v_{i} = \left\{ \begin{matrix} {{\frac{1}{2^{n - 1}}{\sum\limits_{j = 1}^{2^{n}}g_{{2j} - 1}^{*}}} - g_{i}^{*}} & {{for}\quad i\quad {odd}} \\ {{\frac{1}{2^{n - 1}}{\sum\limits_{j = 1}^{2^{n}}g_{2j}^{*}}} - g_{i}^{*}} & {{for}\quad i\quad {even}} \end{matrix} \right.} & (16) \end{matrix}$

[0090] Therefore, in order to calculate a component v_(i) of the output vector it is sufficient to calculate a weighted sum of even $\left( {\frac{1}{2^{n - 1}}{\sum\limits_{j = 1}^{2^{n}}g_{2j}^{*}}} \right)$

[0091] or odd $\left( {\frac{1}{2^{n - 1}}{\sum\limits_{j = 1}^{2^{n}}g_{{2j} - 1}^{*}}} \right)$

[0092] components of the numeric entanglement vector, and to subtract from it the corresponding component g_(i)* of the numeric entanglement vector.

[0093] According to the above formulas, the pre-interference sum block of the interference subsystem depicted in FIG. 11 has adders generating voltage signals representing scaled sums of odd (s1) and even (s2) components with a scale factor of ½^(n−1) (0.5 in this case). The interference subsystem further comprises an array of adders input with a voltage representing a component of the numeric entanglement vector (d1, . . . , d8) and with a respective scaled sum (s1 or s2) for generating voltages representing components (i1, . . . , i8) of the output vector.

[0094] When the Grover's algorithm terminates, only two of them (i3, i4) may assume values close to ${{\pm \frac{1}{\sqrt{2}}} = {\pm 0.7071067}},$

[0095] denoting the position of the searched element. With the same entanglement as in the previous section, third and fourth OPAMPs (i3 and i4) must have non-zero values. This fact is confirmed by the PSPICE simulation depicted in FIG. 11 (707 mV against 0.1 mV of other outputs).

[0096] As evident to one skilled in the art, the computational speed is significantly increased because of a smaller number of products (only one for each element of the output vector), and more precisely 2^(n+1) against 4^(n+1) of traditional approaches. Even the number of additions has been reduced (2^(n)(2^(n)+1) instead of 4^(n+1)). But the most important fact is that all these operations can be easily carried out via hardware with few operational amplifiers (2^(n)+2) . Moreover, if n is the number of qubits (in the considered example n=2), this embodiment of a quantum gate of the invention calculates only 2^(n+1) products (8) instead of 2^(2n+2) (64) required in prior art methods, thus noticeably reducing the time required for carrying out the entanglement operation.

[0097] It is not necessary to calculate all the components of the entanglement or output vector because the odd components of any vector are always opposite the even components, and it is possible to infer looking at signals d1, d3, d5, d7 and i1, i3, i5, i7. Therefore, it is clear that the number of logic gates or adders in FIGS. 10 and 11 could have been halved simply by carrying out the entanglement and interference operations only on the odd or even components, and by calculating the other components by inverting the first ones. 

That which is claimed is:
 1. A method of performing a Grover's or a Deutsch-Jozsa's quantum algorithm using a certain binary function (f) defined on a space having a basis of vectors of n qubits, comprising carrying out a superposition operation over input vectors for generating components of linear superposition vectors referred on a second basis of vectors of n+1 qubits, an entanglement operation over components of said linear superposition vectors for generating components of numeric entanglement vectors, and an interference operation over components of said numeric entanglement vectors for generating components of output vectors, characterized in that said entanglement operation is carried out by: generating, for components of each superposition vector, corresponding components of a numeric entanglement vector (d1, . . . , d8), each component referred to a respective vector of the second basis being equal to the corresponding component of the respective superposition vector, if said binary function (f) is null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis, or the opposite of the corresponding component of the respective superposition vector, if said binary function (f) is non null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis.
 2. The method of claim 1, wherein said components are the even components of vectors, and the odd components of each output vectors are obtained inverting its even components.
 3. The method of claim 1, wherein said components are the odd components of vectors, and the even components of each output vectors are obtained inverting its odd components.
 4. The method of claim 1, wherein said even or odd components of a numeric entanglement vector (d1, . . . , d8) are obtained carrying out the following operations: encoding components of each linear superposition vector (y_(j)*) with a low logic value if negative and with a high logic value if positive, generating components of encoded superposition vectors (y_(i)); generating, for components of each encoded superposition vector (y_(i)), corresponding components of an encoded entanglement vector (g_(i)), each component referred to a respective vector of the second basis being obtained by copying the corresponding component of the respective encoded superposition vector (y_(i)), if said binary function (f) is null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis, or logically inverting the corresponding component of the respective encoded superposition vector (y_(i)), if said binary function (f) is non null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis; decoding the components of encoded entanglement vectors (g_(i)) generating said components of numeric entanglement vectors (d1, . . . , d8).
 5. The method of claim 4, wherein each of said components of encoded entanglement vector (g_(i)) is obtained by XORing the corresponding component of the encoded superposition vector (y_(i)) with the value of said function in correspondence of said vector of the first basis constituted by said first n qubits.
 6. The method of claim 1 of performing a Grover's quantum algorithm, wherein said interference operation comprises the following operations: calculating a weighed sum with a scale factor (½^(n−1)) of the even or the odd components of a numeric entanglement vector (d1, . . . , d8); generating, respectively, each even or odd component of an output vector (i1, . . . , i8) subtracting a corresponding even or odd component of a numeric entanglement vector (d1, . . . , d8) from said weighed sum (s1, s2).
 7. A quantum gate for running a Grover's or a Deutsch-Jozsa's quantum algorithm using a certain binary function (f) defined on a space having a basis of vectors of n qubits, composed of a superposition subsystem carrying out a superposition operation over components of input vectors for generating components of linear superposition vectors referred on a second basis of vectors of n+1 qubits, an entanglement subsystem carrying out an entanglement operation over components of said linear superposition vectors for generating components of numeric entanglement vectors, and an interference subsystem carrying out an interference operation over components of said numeric entanglement vectors for generating components of output vectors, said entanglement subsystem comprising a command circuit generating a number (2^(n)) of logic command signals encoding the values of said binary function (f) in correspondence of the vectors of the first basis; circuit means, input with said logic command signals, generating, for components of each superposition vector, corresponding signals representing components of a numeric entanglement vector (d1, . . . , d8), each component referred to a respective vector of the second basis being equal to the corresponding component of the respective superposition vector, if said binary function (f) is null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis, or the opposite of the corresponding component of the respective superposition vector, if said binary function (f) is non null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis.
 8. The quantum gate of claim 7, wherein said circuit means encode components of each linear superposition vector (y_(i)*) with a low logic value if negative and with a high logic value if positive, generating signals representing components of an encoded superposition vector (y_(i)), and comprise an array of XOR logic gates each input with a signal representing a component of an encoded superposition vector (y_(i)) and with a relative logic command signal, generating voltage signals representing components of encoded entanglement vectors (g_(i)); an array of the same number of digital/analog converters that decodes components of the encoded entanglement vectors, generating signals representing corresponding components of numeric entanglement vectors (d1, . . . , d8).
 9. The quantum gate of claim 8, wherein each digital/analog converter is an adder that outputs a signal representing the weighed difference with a second scale factor between said component of encoded entanglement vectors (g_(i)) and a reference value (V26, . . . , V33).
 10. The quantum gate of claim 7 for running a Grover's quantum algorithm, wherein said interference subsystem comprises an adder input with voltage signals representing even or odd components of a numeric entanglement vector (d1, . . . , d8) and generating a sum signal (s1, s2) representing a weighed sum with a scale factor (½^(n−1)) of said even or odd components; an array of adders each being input with a respective signal representing an even or odd component, respectively, of a numeric entanglement vector (d1, . . . , d8) and with said sum signal (s1, s2), generating a signal representing an even or odd component, respectively, of output vector (i1, . . . , i8) as the difference between said sum signal (s1, s2) and said signal representing an even or odd component of a numeric entanglement vector (d1, . . . , d8). 